package com.yzy.soft.system.util;

/**
 * <p>Title: �������ӿ��������ݵ���ˮ��</p>
 * <p>
 * <p>Description: </p>
 * <p>
 * <p>Copyright: Copyright (c) 2011</p>
 * <p>
 * <p>Company: </p>
 * Modify:2017-11-30
 *
 * @author caosg/adili
 * @version 3.0
 */

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.yzy.soft.common.persistence.dao.MaxnoMapper;
import com.yzy.soft.common.persistence.model.Maxno;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
public class SerialNoGenerator {

    //系统日志监听类
    private final static Logger cLogger = LoggerFactory.getLogger(SerialNoGenerator.class);

    private static MaxnoMapper maxnoMapper;

    @Autowired
    public void setMaxnoMapper(MaxnoMapper maxnoMapper) {
        this.maxnoMapper = maxnoMapper;
    }
    /**
     * 获取事件号码
     *
     * @return
     */
//    public static synchronized String getEventNo() {
//        return PubFun1.CreateMaxNo("FIEventNo", 20);
//    }

    /**
     * 凭证批次号
     *
     * @return
     */
//    public static synchronized String getBatchNo() {
//        return PubFun1.CreateMaxNo("FinBatch", 15);
//    }
//
    /**
     * 获取主业务数据流水号
     *
     * @return
     */
//    public static synchronized String getMSerialNo() {
//        return PubFun1.CreateMaxNo("FIMSerialNo", 25);
//    }

    /**
     * 获取子业务数据流水号
     *
     * @return
     */
//    public static synchronized String getASerialNo() {
//        return PubFun1.CreateMaxNo("FIASerialNo", 25);
//    }
//
//    /**
//     * 明细凭证数据流水号
//     *
//     * @return
//     */
//    public static synchronized String getFSerialNo() {
//        return "n" + PubFun1.CreateMaxNo("FIFSerialNo", 24);
//    }
//
//    /**
//     * 汇总凭证数据流水号
//     *
//     * @return
//     */
//    public static synchronized String getFGSerialNo() {
//        return PubFun1.CreateMaxNo("FININTERFACE", 20);
//    }
//
//    /**
//     * 校检日志流水号
//     *
//     * @return
//     */
//    public static synchronized String getLogSerialNo() {
//        return PubFun1.CreateMaxNo("FILogSerialNo", 20);
//    }
//
//    /**
//     * 校检错误信息流水号
//     *
//     * @return
//     */
//    public static synchronized String getErrLogSerialNo() {
//        return PubFun1.CreateMaxNo("FIErrSerialNo", 25);
//    }
//
//    /**
//     * 红冲申请号码
//     *
//     * @return
//     */
//    public static synchronized String getRBAppNo() {
//        return PubFun1.CreateMaxNo("FIRBAppNo", 20);
//    }
//
//    /**
//     * 明细中间表ROWID
//     *
//     * @return
//     */
//    public static synchronized String getSubRowID() {
//        return PubFun1.CreateMaxNo("SubRowID", 15);
//    }
//
//    /**
//     * 汇总中间表ROWID
//     *
//     * @return
//     */
//    public static synchronized String getBusCheckNo() {
//        return PubFun1.CreateMaxNo("BusCheckNo", 20);
//    }
//
//    /**
//     * 汇总中间表ROWID
//     *
//     * @return
//     */
//    public static synchronized String getFinCheckNo() {
//        return PubFun1.CreateMaxNo("FinCheckNo", 20);
//    }
//
//    /**
//     * 汇总中间表ROWID
//     *
//     * @return
//     */
//    public static synchronized String getMainRowID() {
//        return PubFun1.CreateMaxNo("MainRowID", 15);
//    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
    public static synchronized String[] getSerialNoByFINDATA(int size) throws
            Exception {
        Wrapper<Maxno> maxnoWrapper = new EntityWrapper<Maxno>();
        maxnoWrapper.where("type={0}", "finData");
        int num = 0; //标记初始的数字
        System.out.println("11111111:" + maxnoMapper);
        System.out.println("11111111:" + size);
        List<Maxno> d = maxnoMapper.selectList(maxnoWrapper);
        if (null == d || d.size() <= 0) {
            //return d.get(0).getMaxno();
//        String tSBql = "select maxno from maxno where notype = 'FINDATA' and nolimit = 'SN' for update";
//
            /***********************************************************************/
            /** 创建新的序列号 **/
            //如果没有创建的话则直接创建并且添加size个序号
            Maxno maxno = new Maxno();
            maxno.setMaxno(String.valueOf(size));
            maxno.setType("finData");
            Integer result = maxnoMapper.insert(maxno);
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('FINDATA','SN'," +
//                                size + ")";
            if (result == null) {
                cLogger.error("CreateMaxNo 插入失败，请重试!");
                Exception e = new Exception("CreateMaxNo 插入失败");
            }
        } else {
            //如果已经有了,只要直接添加就可以
            //num = Integer.parseInt(rsData);
            //tSBql = "update ldmaxno set maxno = maxno + " + size +
            // " where notype = 'FINDATA' and nolimit = 'SN'";
            Maxno maxno = d.get(0);
            num = Integer.valueOf(maxno.getMaxno()).intValue() + 1;
            System.out.println("11111111:" + maxno.getMaxno());
            maxno.setMaxno(String.valueOf(Integer.valueOf(maxno.getMaxno()) + size));
            maxno.setType("finData");
            Integer result = maxnoMapper.update(maxno, maxnoWrapper);
            if (result == null) {
                cLogger.error("CreateMaxNo 更新失败，请重试!");
                Exception e = new Exception("CreateMaxNo 更新失败");
            }


        }
        //表示已经存在 并更新成功 则自动从下一个序列号开始增加
        /****************************************************/
        String[] strArr = new String[size]; //返回数组的长度
        for (int i = 0; i < size; i++) {
            strArr[i] = getStringValue(num + i, 25);
        }
        cLogger.info("流水号生成完毕!");
        return strArr;
    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
//    public static synchronized String[] getSerialNoByFIMSerialNo(int size) throws
//            Exception {
//
//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from ldmaxno where notype = 'FIMSerialNo' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('FIMSerialNo','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'FIMSerialNo' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }
//        /****************************************************/
//        String[] strArr = new String[size]; //返回数组的长度
//        for (int i = 0; i < size; i++) {
//            strArr[i] = getStringValue(num + i, 25);
//        }
//        cLogger.info("流水号生成完毕!");
//        return strArr;
//    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
    public static synchronized String[] getSerialNoByFIFSerialNo(int size){

//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from ldmaxno where notype = 'FIFSerialNo' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('FIFSerialNo','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'FIFSerialNo' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }FIFSerialNo

        Wrapper<Maxno> maxnoWrapper = new EntityWrapper<Maxno>();
        maxnoWrapper.where("type={0}", "FIFSerialNo");
        int num = 0; //标记初始的数字
        System.out.println("11111111:" + maxnoMapper);
        System.out.println("11111111:" + size);
        List<Maxno> d = maxnoMapper.selectList(maxnoWrapper);
        if (null == d || d.size() <= 0) {
            //return d.get(0).getMaxno();
//        String tSBql = "select maxno from maxno where notype = 'FINDATA' and nolimit = 'SN' for update";
//
            /***********************************************************************/
            /** 创建新的序列号 **/
            //如果没有创建的话则直接创建并且添加size个序号
            Maxno maxno = new Maxno();
            maxno.setMaxno(String.valueOf(size));
            maxno.setType("FIFSerialNo");
            Integer result = maxnoMapper.insert(maxno);
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('FINDATA','SN'," +
//                                size + ")";
            if (result == null) {
                cLogger.error("CreateMaxNo 插入失败，请重试!");
                Exception e = new Exception("CreateMaxNo 插入失败");
            }
        } else {
            //如果已经有了,只要直接添加就可以
            //num = Integer.parseInt(rsData);
            //tSBql = "update ldmaxno set maxno = maxno + " + size +
            // " where notype = 'FINDATA' and nolimit = 'SN'";
            Maxno maxno = d.get(0);
            num = Integer.valueOf(maxno.getMaxno()).intValue() + 1;
            System.out.println("11111111:" + maxno.getMaxno());
            maxno.setMaxno(String.valueOf(Integer.valueOf(maxno.getMaxno()) + size));
            maxno.setType("FIFSerialNo");
            Integer result = maxnoMapper.update(maxno, maxnoWrapper);
            if (result == null) {
                cLogger.error("CreateMaxNo 更新失败，请重试!");
                Exception e = new Exception("CreateMaxNo 更新失败");
            }
            /****************************************************/

        }
        String[] strArr = new String[size]; //返回数组的长度
        for (int i = 0; i < size; i++) {
            strArr[i] = getStringValue(num + i, 25);
        }
        cLogger.info("流水号生成完毕!");
        return strArr;
    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
//    public static synchronized String[] getSerialNoByFIASerialNo(int size) throws
//            Exception {
//
//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from ldmaxno where notype = 'FIASerialNo' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('FIASerialNo','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'FIASerialNo' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }
//        /****************************************************/
//        String[] strArr = new String[size]; //返回数组的长度
//        for (int i = 0; i < size; i++) {
//            strArr[i] = getStringValue(num + i, 25);
//        }
//        cLogger.error("流水号生成完毕!");
//        return strArr;
//    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
//    public static synchronized String[] getSerialNoBySubRowID(int size) throws
//            Exception {
//
//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from ldmaxno where notype = 'SubRowID' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('SubRowID','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'SubRowID' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }
//        /****************************************************/
//        String[] strArr = new String[size]; //返回数组的长度
//        for (int i = 0; i < size; i++) {
//            strArr[i] = getStringValue(num + i, 25);
//        }
//        cLogger.info("流水号生成完毕!");
//        return strArr;
//    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
//    public static synchronized String[] getSerialNoByMainRowID(int size) throws
//            Exception {
//
//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from ldmaxno where notype = 'MainRowID' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('MainRowID','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'MainRowID' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }
//        /****************************************************/
//        String[] strArr = new String[size]; //返回数组的长度
//        for (int i = 0; i < size; i++) {
//            strArr[i] = getStringValue(num + i, 25);
//        }
//        cLogger.info("流水号生成完毕!");
//        return strArr;
//    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
//    public static synchronized String[] getSerialNoByBusCheck(int size) throws
//            Exception {
//
//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from ldmaxno where notype = 'BusCheckNo' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('BusCheckNo','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'BusCheckNo' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }
//        /****************************************************/
//        String[] strArr = new String[size]; //返回数组的长度
//        for (int i = 0; i < size; i++) {
//            strArr[i] = getStringValue(num + i, 20);
//        }
//        cLogger.info("流水号生成完毕!");
//        return strArr;
//    }

    /**
     * 获取校验流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
//    public static synchronized String[] getSerialNoByCheckKey(int size) throws
//            Exception {
//
//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from maxno where notype = 'CheckKeyNo' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('CheckKeyNo','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'CheckKeyNo' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }
//        /****************************************************/
//        String[] strArr = new String[size]; //返回数组的长度
//        for (int i = 0; i < size; i++) {
//            strArr[i] = getStringValue(num + i, 20);
//        }
//        cLogger.info("流水号生成完毕!");
//        return strArr;
//    }

    /**
     * 获取准业务数据流水号
     *
     * @param size 增加数量
     * @return
     * @throws Exception
     */
//    public static synchronized String[] getSerialNoByFinCheck(int size) throws
//            Exception {
//
//        int num = 0; //标记初始的数字
//        String tSBql = "select maxno from ldmaxno where notype = 'FinCheckNo' and nolimit = 'SN' for update";
//        Connection conn = DBConnPool.getConnection();
//        try {
//            conn.setAutoCommit(false);
//            ExeSQL exeSQL = new ExeSQL(conn);
//            String rsData = null;
//            rsData = exeSQL.getOneValue(tSBql.toString());
//            /***********************************************************************/
//            /** 创建新的序列号 **/
//            //如果没有创建的话则直接创建并且添加size个序号
//            if ((rsData == null) || rsData.equals("")) {
//                tSBql =
//                        "insert into ldmaxno(notype, nolimit, maxno) values('FinCheckNo','SN'," +
//                                size + ")";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 插入失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 插入失败");
//                    throw e;
//                } else {
//                    num = 1;
//                }
//            } else {
//                //如果已经有了,只要直接添加就可以
//                num = Integer.parseInt(rsData);
//                tSBql = "update ldmaxno set maxno = maxno + " + size +
//                        " where notype = 'FinCheckNo' and nolimit = 'SN'";
//                exeSQL = new ExeSQL(conn);
//                if (!exeSQL.execUpdateSQL(tSBql.toString())) {
//                    cLogger.error("CreateMaxNo 更新失败，请重试!");
//                    conn.rollback();
//                    conn.close();
//                    Exception e = new Exception("CreateMaxNo 更新失败");
//                    throw e;
//                } else {
//                    num = Integer.parseInt(rsData) + 1; //表示已经存在 并更新成功 则自动从下一个序列号开始增加
//                }
//            }
//            conn.commit();
//            conn.close();
//        } catch (Exception ex) {
//            try {
//                conn.rollback();
//                conn.close();
//            } catch (Exception ex1) {
//                cLogger.error("流水号的错误!" + ex1.getMessage());
//                throw ex1;
//            }
//            throw ex;
//        }
//        /****************************************************/
//        String[] strArr = new String[size]; //返回数组的长度
//        for (int i = 0; i < size; i++) {
//            strArr[i] = getStringValue(num + i, 20);
//        }
//        cLogger.info("流水号生成完毕!");
//        return strArr;
//    }

    /**
     * 把相关的数字转换成相应长度的流水号
     *
     * @param n 需要转换的数字,size则是转换后的长度
     * @return String
     */
    public static String getStringValue(int n, int size) {

        String str = Integer.toString(n);
        int len = str.length();
        String temp = "0000000000000000000000000000";
        str = temp.substring(0, size - len) + str; //未满的用0补充
        return str;
    }


}